import Store from '@/lib/store';
import Utils from '@/lib/utils';
import Config from '@/lib/config';
import Http from '@/lib/http';
import urlMap from './urlMap';
// import Router from './useRouter';

export class Lib{
    constructor(){
        this.$store = Store; // 数据存储
        this.$utils = Utils; // 工具
        this.$http = Http; // 请求
        this.$config = Config // 配置
        this.$urlMap = urlMap // 请求地址

         this.$http.interceptor = {
             before: this.http_before.bind(this),
             after: null
         };
    }
    static getInstance() {
        if (!this.instance) {
            this.instance = new Lib()
        }
        return this.instance
    }


    /**
     * 发送请求前的回调
     * @param {Object} _config - 配置
     * */
    http_before(_config) {
        /*        // 获取权限 permission
                if (_config.permission) {
                    let permissions = _config.permission.toString().split(',');
                    let _hasPermission = true;
                    for (let i = 0, leng = permissions.length; i < leng; i++) {
                        if (!this.checkPermission(permissions[i])) {
                            _hasPermission = false;
                            break;
                        }
                    }
                    // 如果该用户没有检测的权限，不继续执行
                    if (!_hasPermission) {
                        return false;
                    }
                }*/
        // 该请求是否需要登录
        if (_config.needLogin) {
            if (!this.checkIfLogin()) {
                return false;
            }
            let userinfo = this.getUserinfo();
            let _token = userinfo.token;

            if (_token) {
                _config['header']['token'] = _token;

                if (_config.url.indexOf('?') === -1) {
                    _config.url =
                        `${_config.url}?token=${_token}`;
                } else {
                    _config.url = _config.url.replace('?',
                        `?token=${_token}&`);
                }

                if (_config.data.length == 0) {
                    _config.data = `token=${_token}`;
                } else {
                    _config.data = `${_config.data}&token=${_token}`;
                }
            } else {
                return false;
            }
        }

        return _config;
    }
    /**
     * 检查是否登录
     * @param {object} objs
     * @returns {boolean} 如果登录状态正常，如果正常，返回true，否则返回false
     */
    checkIfLogin() {
        let userinfo = this.getUserinfo();
        // 检查是否登录
        // ①：检查用户数据是否存在
        // ②：检查token是否过期
        if (userinfo) {
            if (userinfo.token) {
                return true;
                // 判断token是否过期
                let now = Date.parse(new Date());

                if (userinfo.expire_time === 0 || userinfo.expire_time > now) {
                    return true; // 登录态正常
                }
            }
        }
        // 退出登录
        this.logout();

        return false; // 登录失效
    }
    /**
     * 获取当前用户信息
     * @returns {object} 如果登录状态正常返回用户信息，否则返回空对象{}
     */
    getUserinfo() {
        let userinfo = this.$store.getters.user_Info;
        if (userinfo) {
            if (userinfo.token) {
                return userinfo; // 登录态正常
                /*// 判断token是否过期
                let now = Date.parse(new Date());

                if (userinfo.expire_time === 0 || userinfo.expire_time > now) {
                    return userinfo; // 登录态正常
                }*/
            }
        }
        // 退出登录
        this.logout();
        return {};
    }
    /**
     * 退出登录
     * @returns {boolean} 如果退出登录成功返回true，否则返回false
     */
    logout() {
        // let res = await Http.post({
        //   url: Http.urlMap.logout,
        //   data: {
        //     token: _token
        //   },
        //   needLogin: true
        // });
        // if (res.code === 1) {
        this.$store.commit('clearUserInfo');
        this.login();
        //  return true;
        // } else {
        //  return false;
        // }
        // 发送退出登录请求
        // 根据结果判断是否退出成功
        // ①：如果成功
        // 清空权限系统的该用户数据
        // 从vuex中删除用户
        // 删除该用户token数据
        // 返回true
        // ②：如果失败
        // 返回false
        return true
    }

    login(){
        // console.log('获取code')
        let that = this
    /*    dd.ready(function() {
            // dd.ready参数为回调函数，在环境准备就绪时触发，jsapi的调用需要保证在该回调函数触发后调用，否则无效。
            dd.runtime.permission.requestAuthCode({
                corpId: that.corpid,
                onSuccess: function(result) {
                    that.code=result.code
                    that.getDingUser();
                    // that.$lib.$store.commit('setIsLogin',true);
                },
                onFail : function(err) {
                    console.log(err)
                }
            });
        });*/
    }
    /**
     * 被动授权
     * */
    passive_authorize(params) {
        // console.log(params)
        uni.showLoading();
        if (params.detail) {
            if (params.detail.errMsg == 'getUserInfo:ok') {
                this.getLoginCode();
            }
        }
    }
    /**
     * 获取微信登录code
     * */
    getLoginCode() {
        let that = this;
        console.log('根据获取到的用户信息处理业务代码');
        //接下来写业务代码
        uni.login({
            provider: 'weixin',
            success: function(res) {
                if (res.errMsg == "login:ok") {
                    that.getUserInfo(res);
                }
            }
        });
    }
    /**
     * 获取到用户信息
     * */
    getUserInfo(loginCode) {
        let that = this;
        // 获取用户信息
        uni.getUserInfo({
            provider: 'weixin',
            success(res) {
                console.log('获取用户信息成功');
                uni.hideLoading();

                /*   let userinfo=res.userInfo;
                   that.$lib.$store.commit('setUserInfo', userinfo);
                   console.log(that.userInfo)
                   uni.showToast({
                       icon: 'success',
                       title: '登录成功'
                   })*/


                //此处得到userInfo
                if (res.errMsg == 'getUserInfo:ok') {
                    //接下来写业务代码
                    that.bindGetUserInfo({
                        ...loginCode,
                        ...res
                    });
                }

            },
            fail() {
                console.log('获取用户信息失败');
            }
        });
    }
    /**
     * 添加用户到后台数据库中
     * */
    async bindGetUserInfo(params) {
        let res = await this.$lib.$http.post({
            url: this.$lib.$urlMap.oauthMiniUser,
            data: {
                code: params.code,
                // signature: params.signature,
                // encryptedData: params.encryptedData,
                // iv: params.iv,
                rawData: params.rawData
            },
            permission: '',
            need_login: false,
        });

        if (res.code == 1) {
            uni.hideLoading();

            // 注册用户成功
            // 保存用户信息
            let userinfo = {
                'user_id': res.data.user_id,
                'user_enabled': res.UserEnabled,
                avatarUrl: params.userInfo.avatarUrl,
                city: params.userInfo.city,
                country: params.userInfo.country,
                gender: params.userInfo.gender,
                language: params.userInfo.language,
                nickName: params.userInfo.nickName,
                province: params.userInfo.province,
                expire_time: 0,
                token: res.data.token,
            };

            this.$lib.$store.commit('setUserInfo', userinfo);

            uni.showToast({
                icon: 'success',
                title: '登录成功'
            })
        } else {
            this.canIUse = wx.canIUse('button.open-type.getUserInfo');
        }
    }


}

let _myLib = Lib.getInstance();
export default _myLib;